Изучите Python за 10 минут

28 June 2025 — Язык Программирования

Python — это высокоуровневый интерпретируемый язык программирования, известный своим лаконичным синтаксисом и мощными возможностями. Это руководство основано на последней версии Python 3.13+ и поможет вам быстро освоить Python.

1. Написание первой программы на Python

Начнем с простой программы. Создайте файл с именем hello.py и введите следующий код:

print("Привет, мир!")

Сохраните файл и выполните следующую команду в терминале или командной строке:

python hello.py

Результат будет следующим:

Привет, мир!

Эта простая программа демонстрирует базовую функцию вывода в Python. Функция print() используется для отображения текстовой информации в консоли.

2. Базовый синтаксис

Синтаксис Python прост и понятен. Python использует отступы для определения блоков кода, в отличие от других языков, использующих фигурные скобки {}.

# Это комментарий
print("Привет, мир!")

Основные правила синтаксиса Python:

Отступы: По умолчанию используются 4 пробела для обозначения уровня блока кода. Например, код внутри функций или циклов должен быть с отступом.
Комментарии: Однострочные комментарии начинаются с #, многострочные — с тройных кавычек """ или '''.
Операторы: Обычно один оператор в строке, точка с запятой ; в конце не требуется.
Блоки кода: Определяются отступами, например, для if, for или тел функций.

Пример с многострочным комментарием:

"""
Это многострочный комментарий,
занимающий несколько строк.
"""

Отступы — ключевая особенность синтаксиса Python, используемая для определения иерархической структуры блоков кода:

if True:
    print("Эта строка с отступом")
    print("Эта строка тоже с отступом")
print("Эта строка без отступа")

3. Переменные и типы данных

В Python переменные — это контейнеры для хранения данных. Python — динамически типизированный язык, что означает, что тип переменной не нужно объявлять заранее.

Основные правила именования переменных:

Имена переменных могут содержать только буквы, цифры и подчеркивания.
Имена переменных не могут начинаться с цифры.
Имена переменных чувствительны к регистру.
Ключевые слова Python нельзя использовать в качестве имен переменных.

Тип переменной определяется присваиваемым значением. Основные базовые типы данных Python:

Целое число (int): например, 42 или -10, без ограничения размера.
Вещественное число (float): например, 3.14 или 2.5e3 (научная нотация).
Строка (str): например, "привет" или 'мир', используются одинарные или двойные кавычки.
Булевый тип (bool): True или False.
Тип None (None): Представлен None, обозначает отсутствие значения.

Python поддерживает аннотации типов для улучшения читаемости кода, используемые для статической проверки и поддержки IDE, без влияния на поведение во время выполнения:

name: str = "Алиса"
age: int = 25

3.1 Числовые типы (Number)

Python поддерживает три числовых типа: целое число (int), вещественное число (float) и комплексное число (complex).

# Целое число
age = 25
population = 1000000

# Вещественное число
temperature = 36.5
pi = 3.14159

# Комплексное число
complex_num = 3 + 4j

3.2 Строка (String)

Строки — это последовательности символов, заключенные в одинарные или двойные кавычки.

single_quote = 'Строка с одинарными кавычками'
double_quote = "Строка с двойными кавычками"
multiline = """Это
многострочная строка"""

Операции со строками:

text = "Программирование на Python"
print(len(text))        # Длина строки
print(text.upper())     # Преобразование в верхний регистр
print(text.lower())     # Преобразование в нижний регистр
print(text[0])          # Доступ к первому символу
print(text[2:6])        # Срез строки

3.3 Булевый тип (Boolean)

Булевый тип имеет два значения: True и False.

is_active = True
is_complete = False

# Булевы операции
result1 = True and False  # False
result2 = True or False   # True
result3 = not True        # False

3.4 Тип None (None)

None обозначает отсутствие значения.

value = None

if value is None:
    print("Значение равно null")

4. Структуры данных

Python предоставляет несколько встроенных структур данных для хранения и обработки данных. Ниже описаны часто используемые структуры данных и их применение.

4.1 Список (List)

Список — это упорядоченная и изменяемая коллекция. Вы можете добавлять, удалять или изменять элементы списка. Списки определяются с помощью квадратных скобок [].

numbers = [1, 2, 3, 4, 5]
numbers.append(6)      # Добавление элемента
numbers.insert(0, 0)   # Вставка в определенную позицию
numbers.remove(3)      # Удаление определенного значения
numbers[0] = 10        # Изменение элемента
print(numbers)         # [10, 2, 4, 5, 6]

Срез списка для доступа к подспискам:

numbers = [10, 20, 30, 40, 50]
print(numbers[1:4])    # Вывод: [20, 30, 40]
print(numbers[:3])     # Вывод: [10, 20, 30]
print(numbers[-2:])    # Вывод: [40, 50]

Генерация списков (List comprehension):

squares = [x**2 for x in range(5)]
print(squares)         # [0, 1, 4, 9, 16]

even_squares = [x**2 for x in range(10) if x % 2 == 0]
print(even_squares)    # [0, 4, 16, 36, 64]

4.2 Кортеж (Tuple)

Кортеж — это упорядоченная, но неизменяемая коллекция. После создания элементы кортежа нельзя изменить. Кортежи определяются с помощью круглых скобок (). Благодаря неизменяемости кортежи работают быстрее списков и могут использоваться в качестве ключей словаря.

point = (10, 20)
x, y = point  # Распаковка
print(x, y)   # Вывод: 10 20

Кортеж с одним элементом требует запятую:

single_tuple = (42,)

4.3 Словарь (Dict)

Словарь — это неупорядоченная (упорядоченная в Python 3.7+) коллекция пар ключ-значение. Каждый ключ уникален и связан со значением. Словари определяются с помощью фигурных скобок {}.

student = {
    "name": "Джон",
    "age": 20,
    "major": "Информатика"
}

# Доступ и изменение словаря
print(student["name"])
student["age"] = 21
student["gpa"] = 3.8

# Безопасный доступ
print(student.get("phone", "Не указано"))

# Итерация по словарю
for key, value in student.items():
    print(f"{key}: {value}")

Генерация словарей (Dictionary comprehension):

# Создание словаря квадратов
squares_dict = {x: x**2 for x in range(5)}
print(squares_dict)  # {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

# Условная генерация словаря
even_squares_dict = {x: x**2 for x in range(10) if x % 2 == 0}
print(even_squares_dict)  # {0: 0, 2: 4, 4: 16, 6: 36, 8: 64}

4.4 Множество (Set)

Множество — это неупорядоченная коллекция без дубликатов. Определяется с помощью фигурных скобок {} или функции set().

# Создание множества
fruits = {"яблоко", "банан", "апельсин"}
numbers = set([1, 2, 3, 3, 4, 4, 5])  # Автоматическое удаление дубликатов
print(numbers)  # {1, 2, 3, 4, 5}

# Операции с множествами
set1 = {1, 2, 3, 4}
set2 = {3, 4, 5, 6}

print(set1 | set2)  # Объединение: {1, 2, 3, 4, 5, 6}
print(set1 & set2)  # Пересечение: {3, 4}
print(set1 - set2)  # Разность: {1, 2}
print(set1 ^ set2)  # Симметрическая разность: {1, 2, 5, 6}

5. Операции и операторы

Python предоставляет широкий набор операторов для различных вычислений и сравнений, включая арифметические, сравнения, логические, побитовые и операторы идентичности.

Арифметические операторы: +, -, *, /, // (целочисленное деление), % (остаток), ** (возведение в степень).
Операторы сравнения: ==, !=, >, <, >=, <=.
Логические операторы: and, or, not.
Операторы принадлежности: in, not in.
Операторы идентичности: is, is not.

5.1 Арифметические операторы

Арифметические операторы используются для математических операций. Приоритет операторов соответствует математическим правилам (например, ** имеет более высокий приоритет, чем + или -). Скобки () можно использовать для изменения приоритета.

a, b = 10, 3

print(f"Сложение: {a + b}")      # 13
print(f"Вычитание: {a - b}")     # 7
print(f"Умножение: {a * b}")     # 30
print(f"Деление: {a / b}")       # 3.333...
print(f"Целочисленное деление: {a // b}")  # 3
print(f"Остаток: {a % b}")       # 1
print(f"Возведение в степень: {a ** b}")  # 1000

5.2 Операторы сравнения

Операторы сравнения сравнивают два значения и возвращают булево значение (True или False).

x, y = 5, 10

print(f"Равно: {x == y}")     # False
print(f"Не равно: {x != y}")  # True
print(f"Больше: {x > y}")     # False
print(f"Меньше: {x < y}")     # True
print(f"Больше или равно: {x >= y}")  # False
print(f"Меньше или равно: {x <= y}")  # True

5.3 Логические операторы

Логические операторы объединяют или манипулируют булевыми значениями (True или False), обычно используются в условных операторах.

a, b = True, False

print(f"Операция AND: {a and b}")  # False
print(f"Операция OR: {a or b}")    # True
print(f"Операция NOT: {not a}")    # False

5.4 Операторы идентичности

Оператор is сравнивает идентичность двух объектов, проверяя, ссылаются ли они на один и тот же адрес в памяти (не только равенство значений). Отличается от ==, который сравнивает содержимое.

list1 = [1, 2, 3]
list2 = [1, 2, 3]
list3 = list1

print(f"list1 is list2: {list1 is list2}")    # False
print(f"list1 is list3: {list1 is list3}")    # True
print(f"list1 == list2: {list1 == list2}")    # True

5.5 Операторы принадлежности

Операторы принадлежности проверяют, является ли значение элементом последовательности (например, списка, кортежа, строки, множества), возвращая булево значение.

fruits = ["яблоко", "банан", "апельсин"]

print(f"'яблоко' в fruits: {'яблоко' in fruits}")        # True
print(f"'виноград' не в fruits: {'виноград' not in fruits}")  # True

6. Управление потоком

Python предоставляет несколько операторов управления потоком для управления порядком выполнения программы.

6.1 Операторы if

Оператор if оценивает условие и выполняет блок кода, если условие истинно. Используйте elif и else для сложных условий.

age = 20
if age >= 18:
    print("Взрослый")
elif age >= 13:
    print("Подросток")
else:
    print("Ребенок")

6.2 Циклы for

Цикл for выполняет итерацию по итерируемому объекту (например, списку, кортежу, строке или диапазону).

# Итерация по списку
fruits = ["яблоко", "банан", "вишня"]
for fruit in fruits:
    print(fruit)

# Использование range() для цикла
for i in range(5):
    print(i)  # Вывод: 0, 1, 2, 3, 4

6.3 Циклы while

Цикл while продолжает выполнять блок кода, пока его условие остается истинным.

count = 0
while count < 5:
    print(count)
    count += 1

break и continue: break прерывает цикл, continue пропускает текущую итерацию.

for i in range(10):
    if i == 5:
        break
    if i % 2 == 0:
        continue
    print(i)  # Вывод: 1, 3

6.4 Операторы match

Введенные в Python 3.10, операторы match обеспечивают мощное соответствие структурным шаблонам, выступая в качестве продвинутой альтернативы цепочкам if/elif/else.

http_status = 200

match http_status:
    case 200 | 201:
        print("Успех")
    case 404:
        print("Не найдено")
    case 500:
        print("Ошибка сервера")
    case _:  # Подстановочный символ, соответствует любому другому случаю
        print("Неизвестный статус")

7. Ввод и вывод

7.1 Базовый ввод и вывод

Используйте функцию input() для получения ввода от пользователя и функцию print() для вывода информации.

# Получение ввода от пользователя
name = input("Пожалуйста, введите ваше имя: ")
age = int(input("Пожалуйста, введите ваш возраст: "))

# Вывод информации
print("Добро пожаловать", name)
print("Вам", age, "лет")

7.2 Форматированный вывод (f-строки)

Введенные в Python 3.6+, f-строки (форматированные строковые литералы) — это удобный и мощный способ форматирования строк. Добавьте префикс f или F к строке и вставляйте переменные или выражения в фигурные скобки {}.

user = "Алиса"
items = 3
total_cost = 45.5

# Использование f-строки для форматированного сообщения
message = f"Пользователь {user} купил {items} предметов за ${total_cost:.2f}."
print(message)

# Выражения в f-строках
print(f"2 + 3 равно {2 + 3}")

Выражения и вызовы функций в f-строках:

width = 10
height = 5

# Использование выражений в f-строках
area = f"Площадь прямоугольника: {width * height}"
print(area)

# Вызов функций
text = "python"
formatted = f"Верхний регистр: {text.upper()}, Длина: {len(text)}"
print(formatted)

Параметры форматирования в f-строках:

pi = 3.14159265359
large_number = 1234567

# Форматирование чисел
print(f"Pi (2 знака после запятой): {pi:.2f}")
print(f"Pi (4 знака после запятой): {pi:.4f}")
print(f"Большое число (тысячи): {large_number:,}")
print(f"Процент: {0.85:.1%}")

# Выравнивание строк
name = "Python"
print(f"Выравнивание по левому краю: '{name:<10}'")
print(f"Выравнивание по правому краю: '{name:>10}'")
print(f"Выравнивание по центру: '{name:^10}'")

Форматирование даты и времени с f-строками:

from datetime import datetime

now = datetime.now()
print(f"Текущее время: {now}")
print(f"Форматированное время: {now:%Y-%m-%d %H:%M:%S}")
print(f"Только дата: {now:%Y-%m-%d}")

9. Функции

Функции в Python — это многократно используемые блоки кода для выполнения конкретных задач, определяемые с помощью ключевого слова def, поддерживающие параметры по умолчанию, переменное количество аргументов и именованные аргументы.

Базовое определение функции:

def greet(name):
    """Функция приветствия"""
    return f"Привет, {name}!"

# Вызов функции
message = greet("Джон")
print(message)

Именованные аргументы:

Именованные аргументы передаются с использованием синтаксиса имя_параметра=значение.

def greet(name, greeting="Привет"):
    return f"{greeting}, {name}!"

print(greet("Алиса"))          # Вывод: Привет, Алиса!
print(greet("Боб", "Здравствуй"))     # Вывод: Здравствуй, Боб!

Переменные аргументы:

Переменные аргументы позволяют функциям принимать произвольное количество аргументов, либо позиционных (*args), либо именованных (**kwargs).

# Позиционные переменные аргументы (*args)
def sum_numbers(*args):
    return sum(args)

print(sum_numbers(1, 2, 3, 4))  # Вывод: 10

# Именованные переменные аргументы (**kwargs)
def print_kwargs(**kwargs):
    for key, value in kwargs.items():
        print(f"{key}: {value}")

print_kwargs(name="Алиса", age=25, city="Москва")

Аннотации функций:

Аннотации функций добавляют описательные метаданные к параметрам и возвращаемым значениям функций, улучшая читаемость и документацию.

def calculate_area(length: float, width: float) -> float:
    """Вычисление площади прямоугольника"""
    return length * width

def process_user(name: str, age: int, active: bool = True) -> dict:
    """Обработка информации о пользователе"""
    return {
        "name": name,
        "age": age,
        "active": active
    }

10. Лямбда-выражения

Лямбда-выражения создают анонимные функции, предоставляя краткий способ определения небольших функций.

square = lambda x: x ** 2
print(square(5))  # Вывод: 25

Часто используются с функциями высшего порядка, такими как map или filter:

numbers = [1, 2, 3, 4]
squares = list(map(lambda x: x ** 2, numbers))
print(squares)  # Вывод: [1, 4, 9, 16]

11. Классы и объекты

Python поддерживает объектно-ориентированное программирование с использованием ключевого слова class:

class Person:
    """Класс Person"""
    
    def __init__(self, name, age):
        """Конструктор"""
        self.name = name
        self.age = age
    
    def introduce(self):
        """Метод представления"""
        return f"Я {self.name}, мне {self.age} лет"
    
    def have_birthday(self):
        """Метод дня рождения"""
        self.age += 1
        return f"{self.name} отметил день рождения, теперь {self.age} лет"

# Создание объектов
person1 = Person("Джон", 25)
person2 = Person("Джейн", 30)

print(person1.introduce())
print(person2.have_birthday())

11.1 Атрибуты класса и экземпляра

В Python существуют два типа атрибутов для хранения данных в классах и объектах: атрибуты класса и атрибуты экземпляра.

Атрибуты класса: Определяются вне методов, принадлежат самому классу и разделяются между всеми экземплярами.
Атрибуты экземпляра: Определяются в методах (обычно __init__), привязаны к конкретным экземплярам через self.

class Student:
    # Атрибуты класса
    school = "Университет Стэнфорда"
    student_count = 0
    
    def __init__(self, name, major):
        # Атрибуты экземпляра
        self.name = name
        self.major = major
        Student.student_count += 1
    
    @classmethod
    def get_student_count(cls):
        """Метод класса"""
        return cls.student_count
    
    @staticmethod
    def is_valid_age(age):
        """Статический метод"""
        return 0 < age < 150

# Пример использования
student1 = Student("Джон", "Информатика")
student2 = Student("Джейн", "Математика")

print(f"Университет: {Student.school}")
print(f"Общее количество студентов: {Student.get_student_count()}")
print(f"Допустимый возраст: {Student.is_valid_age(20)}")

11.2 Наследование классов

Наследование позволяет классу (подклассу) наследовать атрибуты и методы от другого класса (родительского класса), обеспечивая повторное использование и расширение кода.

class Animal:
    def __init__(self, name, species):
        self.name = name
        self.species = species
    
    def make_sound(self):
        return f"{self.name} издает звук"
    
    def info(self):
        return f"{self.name} — это {self.species}"

class Dog(Animal):
    def __init__(self, name, breed):
        super().__init__(name, "Собака")
        self.breed = breed
    
    def make_sound(self):
        return f"{self.name} лает"
    
    def fetch(self):
        return f"{self.name} приносит мяч"

class Cat(Animal):
    def __init__(self, name, color):
        super().__init__(name, "Кот")
        self.color = color
    
    def make_sound(self):
        return f"{self.name} мяукает"
    
    def climb(self):
        return f"{self.name} лазает по дереву"

# Использование наследования
dog = Dog("Бадди", "Золотистый ретривер")
cat = Cat("Мими", "Рыжий")

print(dog.info())
print(dog.make_sound())
print(dog.fetch())

print(cat.info())
print(cat.make_sound())
print(cat.climb())

11.3 Специальные методы (магические методы)

Специальные методы (или магические методы) — это методы с двойным подчеркиванием, определяющие специфическое поведение, автоматически вызываемое Python в определенных сценариях.

class Rectangle:
    def __init__(self, width, height):
        self.width = width
        self.height = height
    
    def __str__(self):
        """Строковое представление"""
        return f"Прямоугольник({self.width}x{self.height})"
    
    def __repr__(self):
        """Официальное строковое представление"""
        return f"Rectangle(width={self.width}, height={self.height})"
    
    def __eq__(self, other):
        """Сравнение на равенство"""
        if isinstance(other, Rectangle):
            return self.width == other.width and self.height == other.height
        return False
    
    def __lt__(self, other):
        """Сравнение на меньше (по площади)"""
        if isinstance(other, Rectangle):
            return self.area() < other.area()
        return NotImplemented
    
    def __add__(self, other):
        """Операция сложения"""
        if isinstance(other, Rectangle):
            return Rectangle(self.width + other.width, self.height + other.height)
        return NotImplemented
    
    def area(self):
        """Вычисление площади"""
        return self.width * self.height

# Использование специальных методов
rect1 = Rectangle(3, 4)
rect2 = Rectangle(5, 6)
rect3 = Rectangle(3, 4)

print(rect1)           # Прямоугольник(3x4)
print(repr(rect1))     # Rectangle(width=3, height=4)
print(rect1 == rect3)  # True
print(rect1 < rect2)   # True
print(rect1 + rect2)   # Прямоугольник(8x10)

12. Контекстные менеджеры

Контекстные менеджеры обеспечивают правильное получение и освобождение ресурсов, обычно используются с оператором with для управления ресурсами, такими как файлы или подключения к базам данных.

12.1 Использование контекстных менеджеров

Операции с файлами — распространенный случай использования контекстных менеджеров:

with open("example.txt", "r") as file:
    content = file.read()
    print(content)

Оператор with гарантирует автоматическое закрытие файла после выполнения операций.

12.2 Пользовательские контекстные менеджеры

Создавайте пользовательские контекстные менеджеры, определяя методы __enter__ и __exit__:

class DatabaseConnection:
    def __init__(self, database_name):
        self.database_name = database_name
        self.connection = None
    
    def __enter__(self):
        """Вызывается при входе в контекст"""
        print(f"Подключение к базе данных: {self.database_name}")
        self.connection = f"Подключение к {self.database_name}"
        return self.connection
    
    def __exit__(self, exc_type, exc_value, traceback):
        """Вызывается при выходе из контекста"""
        print(f"Закрытие подключения к базе данных: {self.database_name}")
        if exc_type:
            print(f"Произошла ошибка: {exc_type.__name__}: {exc_value}")
        self.connection = None
        return False  # Не подавлять исключения

# Использование пользовательского контекстного менеджера
with DatabaseConnection("user_database") as conn:
    print(f"Использование подключения: {conn}")
    print("Выполнение операций с базой данных...")

Использование модуля contextlib для создания контекстных менеджеров:

from contextlib import contextmanager
import time

@contextmanager
def timer(operation_name):
    """Контекстный менеджер таймера"""
    print(f"Начало {operation_name}")
    start_time = time.time()
    try:
        yield
    finally:
        end_time = time.time()
        print(f"{operation_name} завершено за {end_time - start_time:.2f} секунд")

# Использование декоратора контекстного менеджера
with timer("обработка данных"):
    # Симуляция длительной операции
    time.sleep(1)
    print("Обработка данных...")

13. Обработка исключений

Обработка исключений обеспечивает надежность программы, используя try, except, else и finally для управления исключениями.

try:
    result = 10 / 0
except ZeroDivisionError:
    print("Нельзя делить на ноль!")
else:
    print("Деление успешно")
finally:
    print("Это выполняется всегда")

Вывод:

Нельзя делить на ноль!
Это выполняется всегда

14. Операции с файлами

Python предоставляет простые методы для чтения и записи файлов, обычно используемые с контекстными менеджерами.

14.1 Чтение файлов

Чтение содержимого текстового файла:

with open("example.txt", "r") as file:
    content = file.read()
    print(content)

Чтение построчно:

with open("example.txt", "r") as file:
    for line in file:
        print(line.strip())

14.2 Запись в файлы

Запись в текстовый файл:

with open("output.txt", "w") as file:
    file.write("Привет, Python!\n")

Добавление содержимого:

with open("output.txt", "a") as file:
    file.write("Добавление нового содержимого.\n")

15. Модули и пакеты

Модули — это файлы, содержащие код Python, а пакеты — это директории, содержащие несколько модулей. Импортируйте модули с помощью import:

import math
print(math.sqrt(16))  # Вывод: 4.0

Пример пользовательского модуля (предположим, файл называется mymodule.py):

# mymodule.py
def say_hello():
    return "Привет из модуля!"

Импорт и использование:

import mymodule
print(mymodule.say_hello())  # Вывод: Привет из модуля!

16. Область видимости и пространство имен

16.1 Область видимости

Область видимости определяет регион, где переменная доступна. Python следует правилу LEGB для поиска переменных:

L (Local): Внутри функции или метода класса.
E (Enclosing): Во внешней функции вложенной функции (замыкание).
G (Global): На уровне модуля.
B (Built-in): Встроенные функции и исключения, такие как print() или len().

x = "глобальная x"

def outer_func():
    x = "внешняя x"
    def inner_func():
        x = "локальная x"
        print(x) # Доступ к локальной области видимости x
    inner_func()
    print(x) # Доступ к внешней области видимости x

outer_func()
print(x) # Доступ к глобальной области видимости x

Использование global или nonlocal для изменения переменных области видимости:

x = "глобальная"
def modify_global():
    global x
    x = "измененная"
modify_global()
print(x)  # Вывод: измененная

16.2 Пространство имен

Пространство имен — это отображение имен на объекты, похожее на словарь, где ключи — это имена переменных, а значения — объекты.

Каждый модуль, функция и класс имеют собственное пространство имен, что предотвращает конфликты имен. Используйте globals() и locals() для проверки пространства имен.

a_variable = 10

def some_function():
    b_variable = 20
    # locals() возвращает словарь текущего локального пространства имен
    print(f"Локальные: {locals()}")

print(f"Глобальные: {globals().keys()}") # Выводит ключи глобального пространства имен
some_function()

17. Генераторы

Генераторы — это специальные итераторы, которые генерируют значения по требованию, а не создают все значения сразу, что делает их эффективными с точки зрения памяти для больших наборов данных.

Генераторы используют ключевое слово yield для ленивого возврата значений:

def fibonacci(n):
    a, b = 0, 1
    for _ in range(n):
        yield a
        a, b = b, a + b

for num in fibonacci(5):
    print(num)  # Вывод: 0, 1, 1, 2, 3

18. Многопоточность

Многопоточность позволяет программе выполнять несколько операций одновременно, что полезно для задач, связанных с вводом-выводом, таких как сетевые запросы или операции с файлами.

Модуль threading в Python предоставляет инструменты для создания и управления потоками. Из-за глобальной блокировки интерпретатора (GIL) многопоточность не обеспечивает настоящего параллелизма CPU в одном процессе, но значительно улучшает производительность для задач, связанных с вводом-выводом.

import threading
import time

def worker(thread_name):
    print(f"Поток {thread_name} начинается...")
    time.sleep(2) # Симуляция длительной операции
    print(f"Поток {thread_name} завершился.")

# Создание потоков
thread1 = threading.Thread(target=worker, args=("A",))
thread2 = threading.Thread(target=worker, args=("B",))

# Запуск потоков
thread1.start()
thread2.start()

# Ожидание завершения всех потоков
thread1.join()
thread2.join()

print("Все потоки завершены.")

19. Асинхронное программирование

Асинхронное программирование идеально подходит для сценариев с большим количеством операций ввода-вывода и высокой конкуренцией, используя цикл событий для управления задачами вместо потоков.

Python поддерживает асинхронное программирование с помощью библиотеки asyncio и синтаксиса async/await.

async def: Определяет сопрограмму.
await: Приостанавливает выполнение сопрограммы, ожидая завершения объекта, который можно ожидать.

import asyncio

async def say_hello():
    print("Привет")
    await asyncio.sleep(1) # Неблокирующая задержка, симулирующая ввод-вывод
    print("Мир")

async def main():
    # Создание и ожидание задачи
    await asyncio.create_task(say_hello())

# Запуск главной сопрограммы
asyncio.run(main())

Вывод:

Привет
Мир